package com.example.roleplay.service;

import com.example.roleplay.service.WebSearchService.SearchResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.document.Document;
import org.springframework.ai.vectorstore.VectorStore;
import org.springframework.ai.vectorstore.SearchRequest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;

/**
 * AI增强服务
 * 整合本地知识库检索和网络搜索，为AI对话提供增强的上下文信息
 */
@Service
public class AIEnhancementService {
    
    private static final Logger logger = LoggerFactory.getLogger(AIEnhancementService.class);
    
    @Autowired(required = false)
    private VectorStore vectorStore;
    
    @Autowired(required = false)
    private WebSearchService webSearchService;
    
    @Autowired
    @Qualifier("knowledgeBaseChatClient")
    private ChatClient knowledgeBaseChatClient;
    
    /**
     * 获取增强的上下文信息
     * 
     * @param userText 用户输入文本
     * @param maxResults 最大结果数量
     * @return 上下文信息列表
     */
    public List<String> getEnhancedContext(String userText, int maxResults) {
        logger.info("为用户输入获取增强上下文：{}", userText);
        
        List<String> contextList = new ArrayList<>();
        
        try {
            // 1. 首先尝试本地知识库检索
            List<String> localResults = searchLocalKnowledge(userText, Math.max(1, maxResults / 2));
            if (!localResults.isEmpty()) {
                contextList.addAll(localResults);
                logger.info("从本地知识库获得{}条结果", localResults.size());
            }
            
            // 2. 判断是否需要网络搜索
            if (webSearchService != null && webSearchService.shouldSearch(userText)) {
                logger.info("需要进行网络搜索以获取最新信息");
                
                List<SearchResult> webResults = webSearchService.search(userText, Math.max(1, maxResults / 2));
                if (!webResults.isEmpty()) {
                    List<String> webContexts = webResults.stream()
                            .map(this::formatSearchResult)
                            .collect(Collectors.toList());
                    contextList.addAll(webContexts);
                    logger.info("从网络搜索获得{}条结果", webResults.size());
                }
            }
            
            // 3. 限制总结果数量
            if (contextList.size() > maxResults) {
                contextList = contextList.subList(0, maxResults);
            }
            
            logger.info("总共获得{}条增强上下文", contextList.size());
            
        } catch (Exception e) {
            logger.error("获取增强上下文时发生错误", e);
        }
        
        return contextList;
    }
    
    /**
     * 检索本地知识库
     * 
     * @param query 查询文本
     * @param maxResults 最大结果数量
     * @return 检索结果列表
     */
    private List<String> searchLocalKnowledge(String query, int maxResults) {
        try {
            if (vectorStore == null) {
                logger.debug("向量存储未配置，跳过本地知识库检索");
                return Collections.emptyList();
            }
            
            logger.debug("执行本地知识库检索：{}", query);
            
            // 使用Spring AI 1.0.0的SearchRequest API
            SearchRequest searchRequest = SearchRequest.builder()
                    .query(query)
                    .topK(maxResults)
                    .build();
            
            List<Document> documents = vectorStore.similaritySearch(searchRequest);
            
            return documents.stream()
                    .map(Document::getText)
                    .filter(content -> content != null && !content.trim().isEmpty())
                    .collect(Collectors.toList());
                    
        } catch (Exception e) {
            logger.error("本地知识库检索失败", e);
            return Collections.emptyList();
        }
    }
    
    /**
     * 格式化搜索结果为上下文字符串
     * 
     * @param result 搜索结果
     * @return 格式化的上下文字符串
     */
    private String formatSearchResult(SearchResult result) {
        StringBuilder sb = new StringBuilder();
        
        if (result.getTitle() != null && !result.getTitle().isEmpty()) {
            sb.append("标题：").append(result.getTitle()).append("\\n");
        }
        
        if (result.getContent() != null && !result.getContent().isEmpty()) {
            sb.append("内容：").append(result.getContent()).append("\\n");
        }
        
        if (result.getUrl() != null && !result.getUrl().isEmpty()) {
            sb.append("来源：").append(result.getUrl()).append("\\n");
        }
        
        if (result.getSource() != null && !result.getSource().isEmpty()) {
            sb.append("搜索引擎：").append(result.getSource()).append("\\n");
        }
        
        return sb.toString().trim();
    }
    
    /**
     * 获取知识库回答
     * 
     * @param userText 用户问题
     * @return AI回答
     */
    public String getKnowledgeAnswer(String userText) {
        try {
            logger.info("使用知识库回答用户问题：{}", userText);
            
            // 获取增强上下文
            List<String> contexts = getEnhancedContext(userText, 5);
            
            // 构建增强的提示
            StringBuilder enhancedPrompt = new StringBuilder();
            enhancedPrompt.append("基于以下上下文信息回答用户问题：\\n\\n");
            
            if (!contexts.isEmpty()) {
                enhancedPrompt.append("相关信息：\\n");
                for (int i = 0; i < contexts.size(); i++) {
                    enhancedPrompt.append((i + 1)).append(". ").append(contexts.get(i)).append("\\n\\n");
                }
            }
            
            enhancedPrompt.append("用户问题：").append(userText).append("\\n\\n");
            enhancedPrompt.append("请基于上述信息提供准确、有用的回答。如果上述信息不足以回答问题，请明确说明。");
            
            // 调用知识库AI
            String response = knowledgeBaseChatClient.prompt()
                    .user(enhancedPrompt.toString())
                    .call()
                    .content();
            
            logger.info("知识库AI回答完成");
            return response;
            
        } catch (Exception e) {
            logger.error("获取知识库回答时发生错误", e);
            return "抱歉，当前无法获取相关信息，请稍后重试。";
        }
    }
}